Subject: Re: ACE
From: [email-masked]
To: [email-masked]
Date: 05 Jul 1994 16:25:21 -0800 (PST)

Kimmo just posted a message to the list about ACE. ACE is
essentially a souped-up version of Amiga Basic. It doesn't have any
of the extras (like AMAL) that Amos has. However, it's extremely
stable, the author has an Internet address, and he usually fixes any
bugs as soon as they're reported. The only real problem with it is
that the compiler's kind of a memory hog, and you may have trouble
compiling/assembling any source code larger than 150K.
  When I released my own compiler (not a Basic compiler) a few
months back, I compared it to what other languages I had around. I
thought you might be interested in seeing the results of those
tests. Amos didn't do so good... :)
  The reason for the huge time difference between Struct/C and
ACE/Amos is that neither of the two Basics use register variables.
Assembly language programmers know how important this is.
  I used the Creator version of Amos.

  SAS C 6.2 is a commercial C compiler, published by SAS Institute.
The included assembler and linker were used. The optimization flag
was not used because the optimizer kept throwing the test code away.
(But, looking at the assembly code, I doubt it would have made much
difference)
  Struct is a copyrighted but freely redistributable compiler,
written by Roland Acton. The PhxAss optimizing assembler and PhxLnk
linker, included with Struct, were used.
  AMOS is a commercial BASIC interpreter, written by Francois Lionet
and published by Europress software. The AMOS compiler was used, and
the numbers given are for the compiled versions of the speed tests.
  ACE is a freeware BASIC compiler, written by David Benn. The A68k
assembler and Blink linker, included with ACE, were used.
  The tests were performed on an Amiga 500 with 1 MB chip and 2 MB
fast, running Kickstart 1.3.

Results (numbers represent seconds):

              C     Struct      AMOS      ACE
--------------------------------------------------
Test 1      114        107       662      504
Test 2      230        109      1694     1200
Test 3      441        107      2313      866
Test 4      119        119      1115      660
Test 5      114        114       887      571
Test 6      116         95       660      504
Test 7      130        107       709      538
Test 8      121         76       622      442

  The tests themselves were quite trivial and focused on loop
structures, comparisons, and simple mathematics. They are not
sufficiently general to be called true benchmarks. The tested
operations, however, are important parts of all useful programs.
  TEST 1 was a For/Next loop.
  TEST 2 used the Zeroloop construct, unique to Struct. For/Next
loops with negative steps were used in the other languages.
  TEST 3 was to acquire the remainder from a division and use it in
an If/Then. This was surrounded by a For/Next loop.
  TEST 4 was a Repeat/Until loop. Do/While was substituted in C.
  TEST 5 was a While/Wend loop.
  TEST 6 was a Loop/End Loop construct. For/Next was substituted in
the other languages.
  TEST 7 was a test of literal concatenation. An If/Then, with the
condition containing numeric literals added to a variable, was
surrounded with a For/Next loop.
  TEST 8 was to access memory. A Byte Peek with a computed memory
address was surrounded by For/Next loops. The memory reference
operator with char casting was used in C. Peek was used in AMOS and
ACE.